home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 019a / view002.zip / VIEWFIL.C < prev    next >
C/C++ Source or Header  |  1991-09-14  |  10KB  |  468 lines
  1. /*
  2. View 0.02 - A simple,small,windowed, text file viewer.
  3.  
  4. Copyright (c) 1991 James P. Goodwin.
  5. All rights reserved.
  6.  
  7. Redistribution and use in source and binary forms are per-
  8. mitted provided that the above copyright notice is dupli-
  9. cated in all such forms and that any documentation,
  10. advertising materials, and other materials related to such
  11. distribution and use acknowledge that the software was
  12. developed by James P. Goodwin.
  13.  
  14. THE SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS
  15. OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE
  16. IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PAR-
  17. TICULAR PURPOSE.
  18. */
  19.  
  20.  
  21. #include <stdio.h>
  22. #include <fcntl.h>
  23. #include <sys\types.h>
  24. #include <sys\stat.h>
  25. #include <io.h>
  26. #include <share.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include <dos.h>
  30. #include <share.h>
  31. #include <conio.h>
  32. #include <limits.h>
  33. #include <direct.h>
  34. #include "view.h"
  35.  
  36. /*
  37.   VIEWFILE access routines
  38. */
  39.  
  40. UINT view_getc_bwd( VIEWFILE *vf )
  41. {
  42.    int err;
  43.    UINT ret;
  44.    
  45. #if VIEW_HAS_MEMORY
  46.    if (vf->fh == VIEW_MEM_HDL)
  47.      {
  48.      vf->pos--;
  49.      return(memory[vf->pos]);
  50.      }
  51.    else
  52.      {
  53. #endif
  54.      if (view_tell(vf))
  55.        {
  56.        if (vf->idx == 0)
  57.          {
  58.          view_seek(vf,(-1L),SEEK_CUR);
  59.          ret = vf->buf[vf->idx];
  60.          }
  61.        else
  62.          {
  63.          vf->idx --;
  64.          ret = vf->buf[vf->idx];
  65.          }
  66.  
  67.        return(ret);  
  68.        }
  69.      else
  70.        return(VIEW_EOF);
  71. #if VIEW_HAS_MEMORY
  72.      }
  73. #endif
  74. }
  75.  
  76. UINT view_getc_fwd( VIEWFILE *vf )
  77. {
  78.    UINT ret;
  79.  
  80. #if VIEW_HAS_MEMORY
  81.    if (vf->fh == VIEW_MEM_HDL)
  82.      {
  83.      ret = memory[vf->pos];
  84.      vf->pos ++;
  85.      return(ret);
  86.      }
  87.    else
  88.      {
  89. #endif
  90.      if (vf->idx >= vf->len)
  91.        {
  92.        view_seek(vf,(vf->pos+vf->idx),SEEK_SET);
  93.        if (vf->idx >= vf->len) return(VIEW_EOF);
  94.        }
  95.        
  96.      ret = vf->buf[vf->idx];
  97.      vf->idx ++;
  98.      return(ret);  
  99. #if VIEW_HAS_MEMORY
  100.      }
  101. #endif
  102. }
  103.  
  104.  
  105. #if VIEW_HAS_RAW
  106. UINT view_getl_raw( VIEWFILE *vf, UCHAR *line, int dir )
  107. {
  108.     int          num_normal;
  109.     int          num_input;
  110.     int          num_output;
  111.     int          num_fixup;
  112.     UINT ret;
  113.     int          jdx;
  114.     UCHAR         *offset;
  115.  
  116.     if (vf->lmode == VIEW_BIN_MODE) 
  117.       {
  118.       num_fixup = 11;
  119.       num_input   = VIEW_MAX_BINMODE;
  120.       num_output  = 11+VIEW_MAX_BINMODE;
  121.       }
  122.     else if (vf->lmode == VIEW_HEX_MODE) 
  123.       {
  124.       num_fixup = 60;
  125.       num_input   = VIEW_MAX_HEXMODE;
  126.       num_output  = 11+(num_input*3)+1+num_input;
  127.       }
  128.     else
  129.       return(VIEW_EOF);
  130.  
  131.     for( jdx = 0; jdx < num_output; jdx ++)
  132.       line[jdx] = ' ';
  133.     line[jdx] = '\0';
  134.  
  135.     for (ret = num_normal = 0; num_normal < num_input && ret != VIEW_EOF; num_normal ++ )  
  136.       {  
  137.       if (dir)  
  138.         {  
  139.         ret = view_getc_fwd(vf);  
  140.  
  141.         if (ret != VIEW_EOF)  
  142.           {  
  143.           if (!num_normal)  
  144.             {  
  145. #if VIEW_HAS_MEMORY
  146.             if (vf->fh == VIEW_MEM_HDL)
  147.               offset = view_ultoa((ULONG)(memory+(view_tell(vf)-1L)),16,8,'0');  
  148.             else
  149. #endif
  150.               offset = view_ultoa((view_tell(vf)-1L),10,1,'0');  
  151.  
  152.             for (jdx = 0; jdx < 11 ; jdx ++)  
  153.               if (*offset) line[jdx] = *(offset++);  
  154.             }  
  155.  
  156.           if (vf->lmode == VIEW_HEX_MODE)  
  157.             {  
  158.             line[11+num_normal*3]     = hexdigits[ret/16];  
  159.             line[11+num_normal*3+1]   = hexdigits[ret%16];  
  160.             }  
  161.  
  162.           if (ret) line[num_fixup+num_normal]   = ret;  
  163.           }  
  164.         }  
  165.       else  
  166.         ret = view_getc_bwd(vf);  
  167.       }  
  168.       
  169.     if (!num_normal && ret == VIEW_EOF)
  170.       return(VIEW_EOF);
  171.     else
  172.       return(FALSE);
  173. }
  174. #endif /* VIEW_HAS_RAW */
  175.  
  176.  
  177. UINT view_getl_fwd( VIEWFILE *vf, UCHAR *line, int max )
  178. {
  179.     UINT ret;
  180.     int num_normal;
  181.     int new_idx,old_idx;
  182.  
  183. #if VIEW_HAS_RAW
  184.     if (vf->lmode)
  185.       return(view_getl_raw( vf, line, 1));
  186. #endif
  187.  
  188.     num_normal = 0;
  189.     new_idx    = 0;
  190.     old_idx    = 0;
  191.     ret = 0;
  192.  
  193.     while( (ret != VIEW_EOF) && (num_normal < max) )
  194.       {
  195.       ret = view_getc_fwd(vf);
  196.  
  197.       if (ret == '\n') 
  198.         break;
  199.       else if (ret == '\r')
  200.         continue;
  201.       else if (ret != VIEW_EOF)
  202.         {
  203.         num_normal ++;
  204.         if (new_idx < max) 
  205.           {
  206.           if (ret == TAB)
  207.             {
  208.             old_idx = new_idx;
  209.             new_idx = ((new_idx / 8)*8)+8;
  210.             while(old_idx < new_idx && old_idx < max)
  211.               line[old_idx++] = ' ';
  212.             new_idx = old_idx;
  213.             }
  214.           else if (ret == '\0')
  215.             line[new_idx++] = ' ';
  216.           else
  217.             line[new_idx++] = ret;
  218.           }
  219.         }
  220.       }
  221.  
  222.     line[new_idx] = '\0';
  223.  
  224.     if ((ret == VIEW_EOF) && !num_normal)
  225.       return(VIEW_EOF);
  226.     else
  227.       return(FALSE);
  228. }
  229.  
  230. UINT view_getl_bwd( VIEWFILE *vf, UCHAR *line, int max )
  231. {
  232.     UINT ret;
  233.     int num_newlines;
  234.     int num_normal;
  235.     int new_idx;
  236.  
  237. #if VIEW_HAS_RAW
  238.     if (vf->lmode)
  239.       return(view_getl_raw( vf, line, 0));
  240. #endif
  241.  
  242.     num_normal    = 0;
  243.     num_newlines  = 0;
  244.     ret  = 0;
  245.  
  246.     while ( (ret != VIEW_EOF)  && (num_newlines < 2) && (num_normal < max) )
  247.       {
  248.       ret = view_getc_bwd( vf );
  249.  
  250.       if ((ret == '\n') || ((num_newlines == 0) && (num_normal == 1)))
  251.         num_newlines ++;
  252.       else if (ret == '\r')
  253.         continue;
  254.       else if (ret != VIEW_EOF)
  255.         num_normal ++;
  256.       }
  257.  
  258.     if ((ret == VIEW_EOF) && !num_normal)
  259.       ret = VIEW_EOF;
  260.     else if (ret == '\n')
  261.       {
  262.       view_getc_fwd(vf);
  263.       ret = FALSE;
  264.       }
  265.     else
  266.       ret = FALSE;
  267.  
  268.     return(ret);
  269. }
  270.  
  271. VIEWFILE *view_open( UCHAR *fname )
  272. {
  273.   int th;
  274.   VIEWFILE *vf;
  275.  
  276.   vf = malloc(sizeof(VIEWFILE));
  277.   if (!vf) view_error(1,"VIEW0006");
  278.  
  279.   vf->pos = 0;
  280.   vf->idx = 0;
  281.   vf->len = 0;
  282.   vf->lmode = VIEW_TEXT_MODE;
  283.  
  284.  
  285.   if (fname)
  286.     {
  287.  
  288. #if VIEW_HAS_MEMORY
  289.  
  290.     if (!stricmp(fname,VIEW_MEM_NAME))
  291.       {
  292.       vf->fh = VIEW_MEM_HDL;
  293.       }
  294.     else
  295.  
  296. #endif
  297.     if ((vf->fh = open(fname,O_RDONLY|O_BINARY,S_IREAD|S_IWRITE)) < 0)
  298.       {
  299.       view_error(0,"Cannot Open File");
  300.       free(vf);
  301.       return(NULL);
  302.       }
  303.     }
  304.   else
  305.     {
  306.     if (!(th = open("CON",O_RDONLY,S_IREAD|S_IWRITE)))
  307.       view_error(1,"VIEW0007");
  308.  
  309.     fname     = "Standard Input";
  310.  
  311.     vf->fh    = dup(fileno(stdin));
  312.     setmode(vf->fh,O_BINARY);
  313.     dup2(th,fileno(stdin));
  314.     }
  315.  
  316.    if (vf->fh != VIEW_MEM_HDL)
  317.      {
  318.      vf->end = lseek(vf->fh,0L,SEEK_END);
  319.      vf->pos = lseek(vf->fh,0L,SEEK_SET);
  320.      vf->len = read(vf->fh,vf->buf,VIEW_BUF_SIZE);
  321.      vf->pos = lseek(vf->fh,0L,SEEK_SET);
  322.      }
  323.  
  324.    vf->fname = strdup(fname);
  325.    if (!vf->fname) view_error(1,"VIEW0008");
  326.  
  327.    return(vf);
  328. }
  329.  
  330. void view_close( VIEWFILE *vf )
  331. {
  332.    if (vf->fh != VIEW_MEM_HDL)
  333.      close(vf->fh);
  334.    free(vf->fname);
  335.    free(vf);
  336. }
  337.  
  338.  
  339. ULONG view_tell( VIEWFILE *vf )
  340. {
  341.   if (vf->fh == VIEW_MEM_HDL)
  342.     return(vf->pos);
  343.   else
  344.     return(vf->pos+vf->idx);
  345. }
  346.  
  347. ULONG view_seek( VIEWFILE *vf, long pos, int base )
  348. {
  349.   long tpos;
  350.   long rpos;
  351.   int  size;
  352.  
  353. #if VIEW_HAS_MEMORY
  354.   if (vf->fh == VIEW_MEM_HDL)
  355.     {
  356.     switch( base )
  357.       {
  358.       case SEEK_SET:
  359.       break;
  360.  
  361.       case SEEK_CUR:
  362.         pos = vf->pos + pos;
  363.       break;
  364.         
  365.       case SEEK_END:
  366.         pos = ULONG_MAX + pos;
  367.       break;
  368.       }
  369.  
  370.     vf->pos = pos;
  371.     return(pos);
  372.     }
  373.   else
  374.     {
  375. #endif
  376.     switch( base )
  377.       {
  378.       case SEEK_SET:
  379.         tpos = pos;
  380.       break;
  381.  
  382.       case SEEK_CUR:
  383.         tpos = (((long)vf->pos)+vf->idx)+pos;
  384.       break;
  385.  
  386.       case SEEK_END:
  387.         tpos = ((long)vf->end)+pos;
  388.       break;
  389.       }
  390.  
  391.     if (tpos < 0)       
  392.       {
  393.       vf->idx = 0;
  394.       return(0L);
  395.       }
  396.  
  397.     if (tpos > vf->end) 
  398.       {
  399.       vf->idx = vf->len;
  400.       return(vf->end);
  401.       }
  402.  
  403.     if (labs(tpos-vf->pos) > VIEW_BUF_SIZE)
  404.       {
  405.       vf->idx = 0;
  406.       vf->pos = lseek(vf->fh,tpos,SEEK_SET);
  407.       vf->len = read(vf->fh,vf->buf,VIEW_BUF_SIZE);
  408.       }
  409.     else if (tpos < vf->pos )
  410.       {
  411.       lseek(vf->fh,vf->pos,SEEK_SET);
  412.       size = (VIEW_BUF_SIZE/4);
  413.  
  414.       while ( tpos < vf->pos && size )
  415.         {
  416.         if (size > vf->pos) size = vf->pos;
  417.  
  418.         memmove(vf->buf+size,vf->buf,(VIEW_BUF_SIZE-size));
  419.  
  420.         vf->len += size;
  421.  
  422.         if (vf->len > VIEW_BUF_SIZE) 
  423.           vf->len = VIEW_BUF_SIZE;
  424.  
  425.         lseek(vf->fh,((long)(-size)),SEEK_CUR);
  426.  
  427.         read(vf->fh,vf->buf,size);
  428.  
  429.         vf->pos = lseek(vf->fh,((long)(-size)),SEEK_CUR);
  430.  
  431.         vf->idx = (tpos - vf->pos);
  432.         }
  433.       }
  434.     else if (tpos >= (vf->pos+vf->len))
  435.       {
  436.       rpos = vf->pos + vf->len;
  437.  
  438.       lseek(vf->fh,rpos,SEEK_SET);
  439.       size = (VIEW_BUF_SIZE/4);
  440.  
  441.       while ( tpos >= rpos && size )
  442.         {
  443.         if (size > (vf->end-rpos))
  444.           size = (vf->end-rpos);
  445.  
  446.         if (vf->len > (VIEW_BUF_SIZE-size))
  447.           {
  448.           memmove(vf->buf,vf->buf+size,(VIEW_BUF_SIZE-size));
  449.           vf->len -= size;
  450.           if (vf->len < 0) vf->len = 0;
  451.           }
  452.  
  453.         read(vf->fh,vf->buf+vf->len,size);
  454.  
  455.         vf->len += size;
  456.         rpos    += size;
  457.         vf->pos += size;
  458.  
  459.         vf->idx = (tpos - vf->pos);
  460.         }
  461.       }
  462.     else
  463.       vf->idx = (tpos - vf->pos);
  464. #if VIEW_HAS_MEMORY
  465.     }
  466. #endif
  467. }
  468.